﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Entidades;
using System.Data.SqlClient;
using System.Xml.XPath;
using System.Reflection;
using System.Xml;

namespace DAO
{
    public static class Persisteitor
    {
        private static Dictionary<string, object> diccionario;
        private const string TABLA_USUARIO = "Usuario";
        private const string TABLA_TIPO_USUARIO = "TipoUsuario";
        private const string TABLA_CTA_CTE = "CuentaCorriente";
        private const string TABLA_ETAPA = "Etapa";
        private const string TABLA_PARTIDO = "Partido";
        private const string TABLA_SELECCION = "Seleccion";
        private const string TABLA_BOLETA = "Boleta";
        private const string TABLA_DETALLE_BOLETA = "DetalleBoleta";
        private const string TABLA_DE_POSICIONES = "TablaPosiciones";
        private const string TABLA_DETALLE_TABLA_DE_POSICIONES = "DetalleTablaPosiciones";

        #region USUARIO

        public static int PersistirUsuario(UsuarioEntity entidad)
        {
            UsuarioToMap(entidad);
            return BDServices.InsertCommand(TABLA_USUARIO, diccionario);
        }
        public static void EliminarUsuario(int id)
        {
            BDServices.DeleteCommand(TABLA_USUARIO, id);
        }
        public static void ActualizarUsuario(UsuarioEntity entidad)
        {
            UsuarioToMap(entidad);
            BDServices.UpdateCommand(TABLA_USUARIO, diccionario, entidad.Id);
        }
        public static UsuarioEntity SeleccionarUsuario(int id, bool cerrarConexion)
        {
            UsuarioToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_USUARIO, diccionario, id);
            var usuarios = MapToUsuario(dataReader, cerrarConexion);
            return usuarios[0];
        }
        public static List<UsuarioEntity> SeleccionarTodosUsuarios(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_USUARIO);
            return MapToUsuario(dataReader, cerrarConexion);
        }

        private static void UsuarioToMap(UsuarioEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new UsuarioEntity();
            }

            diccionario.Add("nombre", entidad.Nombre);
            diccionario.Add("apellido", entidad.Apellido);
            diccionario.Add("fechaAlta", entidad.FechaAlta);

            if (entidad.TipoUsuario == null)
            {
                diccionario.Add("tipousuario_id", 0);
            }
            else
            {
                diccionario.Add("tipousuario_id", entidad.TipoUsuario.Id);
            }

            diccionario.Add("login", entidad.Login);
            diccionario.Add("password", entidad.Password);
            diccionario.Add("email", entidad.Email);
        }
        private static List<UsuarioEntity> MapToUsuario(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<UsuarioEntity> lista = new List<UsuarioEntity>();

            while (dataReader.Read())
            {
                UsuarioEntity entidad = new UsuarioEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Nombre = dataReader["nombre"].ToString();
                entidad.Apellido = dataReader["apellido"].ToString();
                entidad.FechaAlta = (DateTime)dataReader["fechaAlta"];
                entidad.TipoUsuario = SeleccionarTipoUsuario((int)dataReader["tipousuario_id"], false);
                entidad.Login = dataReader["login"].ToString();
                entidad.Password = dataReader["password"].ToString();
                entidad.Email = dataReader["email"].ToString();

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region TIPO USUARIO

        public static int PersistirTipoUsuario(TipoUsuarioEntity entidad)
        {
            TipoUsuarioToMap(entidad);
            return BDServices.InsertCommand(TABLA_TIPO_USUARIO, diccionario);
        }
        public static void EliminarTipoUsuario(int id)
        {
            BDServices.DeleteCommand(TABLA_TIPO_USUARIO, id);
        }
        public static void ActualizarUsuario(TipoUsuarioEntity entidad)
        {
            TipoUsuarioToMap(entidad);
            BDServices.UpdateCommand(TABLA_TIPO_USUARIO, diccionario, entidad.Id);
        }
        public static TipoUsuarioEntity SeleccionarTipoUsuario(int id, bool cerrarConexion)
        {
            TipoUsuarioToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_TIPO_USUARIO, diccionario, id);
            var tipoUsuarios = MapToTipoUsuario(dataReader, cerrarConexion);

            return tipoUsuarios[0];
        }
        public static List<TipoUsuarioEntity> SeleccionarTodosTipoUsuario(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_TIPO_USUARIO);
            return MapToTipoUsuario(dataReader, cerrarConexion);
        }

        private static void TipoUsuarioToMap(TipoUsuarioEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new TipoUsuarioEntity();
            }

            diccionario.Add("descripcion", entidad.Descripcion);
        }
        private static List<TipoUsuarioEntity> MapToTipoUsuario(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<TipoUsuarioEntity> lista = new List<TipoUsuarioEntity>();

            while (dataReader.Read())
            {
                TipoUsuarioEntity entidad = new TipoUsuarioEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Descripcion = dataReader["descripcion"].ToString();

                lista.Add(entidad);
            }

            dataReader.Close();
            return lista;
        }

        #endregion

        #region CTA. CTE.

        public static int PersistirCtaCte(CuentaCorrienteEntity entidad)
        {
            CtaCteToMap(entidad);
            return BDServices.InsertCommand(TABLA_CTA_CTE, diccionario);
        }
        public static void EliminarCtaCte(int id)
        {
            BDServices.DeleteCommand(TABLA_CTA_CTE, id);
        }
        public static void ActualizarCtaCte(CuentaCorrienteEntity entidad)
        {
            CtaCteToMap(entidad);
            BDServices.UpdateCommand(TABLA_CTA_CTE, diccionario, entidad.Id);
        }
        public static CuentaCorrienteEntity SeleccionarCtaCte(int id, bool cerrarConexion)
        {
            CtaCteToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_CTA_CTE, diccionario, id);
            var ctaCtes = MapToCtaCte(dataReader, cerrarConexion);

            return ctaCtes[0];
        }
        public static List<CuentaCorrienteEntity> SeleccionarTodasCtaCte(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_CTA_CTE);
            return MapToCtaCte(dataReader, cerrarConexion);
        }

        private static void CtaCteToMap(CuentaCorrienteEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new CuentaCorrienteEntity();
            }

            diccionario.Add("saldo", entidad.Saldo);
            diccionario.Add("montoMovimiento", entidad.MontoMovimiento);
            diccionario.Add("fechaMovimiento", entidad.FechaMovimiento);
            diccionario.Add("descripcion", entidad.Descripcion);
            diccionario.Add("usuario_id", entidad.Usuario.Id);
        }
        private static List<CuentaCorrienteEntity> MapToCtaCte(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<CuentaCorrienteEntity> lista = new List<CuentaCorrienteEntity>();

            while (dataReader.Read())
            {
                CuentaCorrienteEntity entidad = new CuentaCorrienteEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Saldo = (float)(double)dataReader["saldo"];
                entidad.MontoMovimiento = (float)(double)dataReader["montoMovimiento"];
                entidad.FechaMovimiento = (DateTime)dataReader["fechaMovimiento"];
                entidad.Descripcion = dataReader["descripcion"].ToString();
                entidad.Usuario = SeleccionarUsuario((int)dataReader["usuario_id"], false);

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region ETAPA

        public static int PersistirEtapa(EtapaEntity entidad)
        {
            EtapaToMap(entidad);
            return BDServices.InsertCommand(TABLA_ETAPA, diccionario);
        }
        public static void EliminarEtapa(int id)
        {
            BDServices.DeleteCommand(TABLA_ETAPA, id);
        }
        public static void ActualizarEtapa(EtapaEntity entidad)
        {
            EtapaToMap(entidad);
            BDServices.UpdateCommand(TABLA_ETAPA, diccionario, entidad.Id);
        }
        public static EtapaEntity SeleccionarEtapa(int id, bool cerrarConexion)
        {
            EtapaToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_ETAPA, diccionario, id);
            var etapas = MapToEtapa(dataReader, cerrarConexion);
            return etapas[0];
        }
        public static List<EtapaEntity> SeleccionarTodasEtapas(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_ETAPA);
            return MapToEtapa(dataReader, cerrarConexion);
        }

        private static void EtapaToMap(EtapaEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new EtapaEntity();
            }

            diccionario.Add("nombre", entidad.Nombre);
            diccionario.Add("empate", entidad.PermiteEmpate);
            diccionario.Add("valor", entidad.Valor);
            diccionario.Add("fechaInicio", entidad.FechaInicio);
            diccionario.Add("fechaFin", entidad.FechaFin);
        }
        private static List<EtapaEntity> MapToEtapa(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<EtapaEntity> lista = new List<EtapaEntity>();

            while (dataReader.Read())
            {
                EtapaEntity entidad = new EtapaEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Nombre = dataReader["nombre"].ToString();
                entidad.PermiteEmpate = (bool)dataReader["empate"];
                entidad.Valor = float.Parse(dataReader["valor"].ToString());
                entidad.FechaInicio = (DateTime)dataReader["fechaInicio"];
                entidad.FechaFin = (DateTime)dataReader["fechaFin"];

                entidad.EmpateEnGrilla = entidad.PermiteEmpate ? "Si" : "No";
                entidad.ValorEnGrilla = "$" + entidad.Valor.ToString();
                entidad.Partidos = SeleccionarTodosPartidos(false).Where(x => x.EtapaId.HasValue && x.EtapaId.Value == entidad.Id).ToList<PartidoEntity>();
                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region PARTIDO

        public static int PersistirPartido(PartidoEntity entidad)
        {
            PartidoToMap(entidad);
            return BDServices.InsertCommand(TABLA_PARTIDO, diccionario);
        }
        public static void EliminarPartido(int id)
        {
            BDServices.DeleteCommand(TABLA_PARTIDO, id);
        }
        public static void ActualizarPartido(PartidoEntity entidad)
        {
            PartidoToMap(entidad);
            BDServices.UpdateCommand(TABLA_PARTIDO, diccionario, entidad.Id);
        }
        public static PartidoEntity SeleccionarPartido(int id, bool cerrarConexion)
        {
            PartidoToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_PARTIDO, diccionario, id);
            var partidos = MapToPartido(dataReader, cerrarConexion);
            return partidos[0];
        }
        public static List<PartidoEntity> SeleccionarTodosPartidos(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_PARTIDO);
            return MapToPartido(dataReader, cerrarConexion);
        }

        private static void PartidoToMap(PartidoEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new PartidoEntity();
            }

            diccionario.Add("sede", entidad.Sede);
            diccionario.Add("fecha", entidad.Fecha);

            if (entidad.Local == null)
                diccionario.Add("seleccionLocal_id", DBNull.Value);
            else
                diccionario.Add("seleccionLocal_id", entidad.Local.Id);

            if (entidad.GolVisitante.HasValue)
                diccionario.Add("golLocal", entidad.GolLocal);
            else
                diccionario.Add("golLocal", DBNull.Value);

            if (entidad.Visitante == null)
                diccionario.Add("seleccionVisitante_id", DBNull.Value);
            else
                diccionario.Add("seleccionVisitante_id", entidad.Visitante.Id);
            if (entidad.GolVisitante.HasValue)
                diccionario.Add("golVisitante", entidad.GolVisitante);
            else
                diccionario.Add("golVisitante", DBNull.Value);

            if (entidad.EtapaId == null)
                diccionario.Add("etapa_id", DBNull.Value);
            else
                diccionario.Add("etapa_id", entidad.EtapaId);

        }
        private static List<PartidoEntity> MapToPartido(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<PartidoEntity> lista = new List<PartidoEntity>();

            while (dataReader.Read())
            {
                PartidoEntity entidad = new PartidoEntity();
                entidad.Id = (int)dataReader["id"];
                entidad.Sede = dataReader["sede"].ToString();
                entidad.Fecha = (DateTime)dataReader["fecha"];
                entidad.Local = SeleccionarSeleccion((int)dataReader["seleccionLocal_id"], false);
                entidad.Visitante = SeleccionarSeleccion((int)dataReader["seleccionVisitante_id"], false);
                entidad.GolLocal = dataReader["golLocal"] == DBNull.Value ? (int?)null : (int)dataReader["golLocal"];
                entidad.GolVisitante = dataReader["golVisitante"] == DBNull.Value ? (int?)null : (int)dataReader["golVisitante"];
                entidad.EtapaId = dataReader["etapa_id"] == DBNull.Value ? (int?)null : (int)dataReader["etapa_id"];

                entidad.ResultadoEnGrilla = entidad.GolLocal.HasValue && entidad.GolVisitante.HasValue ? entidad.GolLocal.ToString() + " - " + entidad.GolVisitante.ToString() : " - ";
                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region SELECCION

        public static SeleccionEntity SeleccionarSeleccion(int id, bool cerrarConexion)
        {
            SeleccionToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_SELECCION, diccionario, id);
            var seleccion = MapToSeleccion(dataReader, cerrarConexion);

            return seleccion[0];
        }
        public static List<SeleccionEntity> SeleccionarTodasSeleccion(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_SELECCION);
            return MapToSeleccion(dataReader, cerrarConexion);
        }

        private static void SeleccionToMap(SeleccionEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new SeleccionEntity();
            }

            diccionario.Add("nombre", entidad.Nombre);
            diccionario.Add("abreviatura", entidad.Abreviatura);
        }
        private static List<SeleccionEntity> MapToSeleccion(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<SeleccionEntity> lista = new List<SeleccionEntity>();

            while (dataReader.Read())
            {
                SeleccionEntity entidad = new SeleccionEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Nombre = dataReader["nombre"].ToString();
                entidad.Abreviatura = dataReader["abreviatura"].ToString();

                lista.Add(entidad);
            }

            dataReader.Close();
            return lista;
        }

        #endregion

        #region BOLETA

        public static int PersistirBoleta(BoletaEntity entidad)
        {
            List<Dictionary<string, object>> diccionarioDetalle = new List<Dictionary<string, object>>();
            BoletaToMap(entidad);
            foreach (DetalleBoletaEntity d in entidad.Detalle)
                diccionarioDetalle.Add(DetalleBoletaToMap(d));
            return BDServices.InsertCommandMaestroDetalles(TABLA_BOLETA, diccionario, TABLA_DETALLE_BOLETA, diccionarioDetalle, "boleta_id");
        }
        //public static void EliminarBoleta(int id)
        //{
        //    BDServices.DeleteCommand(TABLA_BOLETA, id);
        //}
        public static void ActualizarBoleta(BoletaEntity entidad)
        {
            List<Dictionary<string, object>> diccionarioDetalle = new List<Dictionary<string, object>>();
            BoletaToMap(entidad);
            foreach (DetalleBoletaEntity d in entidad.Detalle)
                diccionarioDetalle.Add(DetalleBoletaToMap(d));
            BDServices.UpdateCommandMaestroDetalle(TABLA_BOLETA, diccionario, TABLA_DETALLE_BOLETA, diccionarioDetalle, "boleta_id", entidad.Id);
        }
        public static BoletaEntity SeleccionarBoleta(int id, bool cerrarConexion)
        {
            BoletaToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_BOLETA, diccionario, id);
            var Boletas = MapToBoleta(dataReader, cerrarConexion);

            return Boletas[0];
        }
        public static List<BoletaEntity> SeleccionarTodasBoleta(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_BOLETA);
            return MapToBoleta(dataReader, cerrarConexion);
        }

        private static void BoletaToMap(BoletaEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new BoletaEntity();
            }

            //diccionario.Add("id", entidad.Id);
            diccionario.Add("usuario_id", entidad.Usuario != null ? entidad.Usuario.Id : (int?)null);
            diccionario.Add("fechaCreacion", entidad.FechaCreacion);
            diccionario.Add("etapa_id", entidad.Etapa != null ? entidad.Etapa.Id : (int?)null);
        }
        private static List<BoletaEntity> MapToBoleta(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<BoletaEntity> lista = new List<BoletaEntity>();

            while (dataReader.Read())
            {
                BoletaEntity entidad = new BoletaEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Usuario = SeleccionarUsuario((int)dataReader["usuario_id"], false);
                entidad.FechaCreacion = (DateTime)dataReader["fechaCreacion"];
                entidad.Etapa = SeleccionarEtapa((int)dataReader["etapa_id"], false);
                entidad.Detalle = SeleccionarTodasDetalleBoleta(false).Where(x => x.BoletaId == entidad.Id).ToList<DetalleBoletaEntity>();

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region DETALLE_BOLETA

        private static int PersistirDetalleBoleta(DetalleBoletaEntity entidad)
        {
            DetalleBoletaToMap(entidad);
            return BDServices.InsertCommand(TABLA_DETALLE_BOLETA, diccionario);
        }
        private static void EliminarDetalleBoleta(int id)
        {
            BDServices.DeleteCommand(TABLA_DETALLE_BOLETA, id);
        }
        private static void ActualizarDetalleBoleta(DetalleBoletaEntity entidad)
        {
            DetalleBoletaToMap(entidad);
            BDServices.UpdateCommand(TABLA_DETALLE_BOLETA, diccionario, entidad.Id);
        }
        private static DetalleBoletaEntity SeleccionarDetalleBoleta(int id, bool cerrarConexion)
        {
            DetalleBoletaToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_DETALLE_BOLETA, diccionario, id);
            var DetalleBoletas = MapToDetalleBoleta(dataReader, cerrarConexion);

            return DetalleBoletas[0];
        }
        private static List<DetalleBoletaEntity> SeleccionarTodasDetalleBoleta(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_DETALLE_BOLETA);
            return MapToDetalleBoleta(dataReader, cerrarConexion);
        }

        private static Dictionary<string, object> DetalleBoletaToMap(DetalleBoletaEntity entidad)
        {
            Dictionary<string, object> diccionarioDetalle = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new DetalleBoletaEntity();
            }

            //diccionario.Add("id", entidad.Id);
            diccionarioDetalle.Add("boleta_id", entidad.BoletaId);
            diccionarioDetalle.Add("partido_id", entidad.Partido.Id);
            diccionarioDetalle.Add("resultado", entidad.Resultado);

            return diccionarioDetalle;
        }
        private static List<DetalleBoletaEntity> MapToDetalleBoleta(SqlDataReader dataReader, bool cerrarConexion)
        {
            List<DetalleBoletaEntity> lista = new List<DetalleBoletaEntity>();

            while (dataReader.Read())
            {
                DetalleBoletaEntity entidad = new DetalleBoletaEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.BoletaId = (int)dataReader["boleta_id"];
                entidad.Partido = SeleccionarPartido((int)dataReader["partido_id"], false);
                entidad.Resultado = dataReader["resultado"].ToString();

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion

        #region TABLA DE POSICIONES

        public static int PersistirTablaPosiciones(TablaPosicionesEntity entidad)
        {
            List<Dictionary<string, object>> diccionarioDetalle = new List<Dictionary<string, object>>();
            TablaPosicionesToMap(entidad);
            foreach (DetalleTablaPosicionesEntity d in entidad.Detalle)
                diccionarioDetalle.Add(DetalleTablaPosicionesToMap(d));
            return BDServices.InsertCommandMaestroDetalles(TABLA_DE_POSICIONES, diccionario, TABLA_DETALLE_TABLA_DE_POSICIONES, diccionarioDetalle, "tabla_id");
        }
        //public static void EliminarTablaPosiciones(int id)
        //{
        //    BDServices.DeleteCommand(TABLA_DE_POSICIONES, id);
        //}
        //public static void ActualizarTablaPosiciones(TablaPosicionesEntity entidad)
        //{
        //    TablaPosicionesToMap(entidad);
        //    BDServices.UpdateCommand(TABLA_DE_POSICIONES, diccionario, entidad.Id);
        //}
        public static TablaPosicionesEntity SeleccionarTablaPosiciones(int id, bool cerrarConexion)
        {
            TablaPosicionesToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_DE_POSICIONES, diccionario, id);
            var lista = MapToTablaPosiciones(dataReader, cerrarConexion);

            return lista != null ? lista[0] : null;
        }
        public static List<TablaPosicionesEntity> SeleccionarTodasTablaPosiciones(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_DE_POSICIONES);
            return MapToTablaPosiciones(dataReader, cerrarConexion);
        }

        private static List<TablaPosicionesEntity> MapToTablaPosiciones(SqlDataReader dataReader, bool cerrarConexion)
        {
            var lista = new List<TablaPosicionesEntity>();

            while (dataReader.Read())
            {
                var entidad = new TablaPosicionesEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.Etapa = SeleccionarEtapa((int)dataReader["etapa_id"], false);
                entidad.Descripcion = dataReader["descripcion"].ToString();
                entidad.Detalle = SeleccionarTodasDetalleTablaPosiciones(false).Where(x => x.TablaId == entidad.Id).ToList<DetalleTablaPosicionesEntity>();

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }
        private static void TablaPosicionesToMap(TablaPosicionesEntity entidad)
        {
            diccionario = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new TablaPosicionesEntity();
            }

            diccionario.Add("etapa_id", entidad.Etapa.Id);
            diccionario.Add("descripcion", entidad.Descripcion);
        }

        #endregion

        #region DETALLE TABLA DE POSICIONES

        public static int PersistirDetalleTablaPosiciones(DetalleTablaPosicionesEntity entidad)
        {
            DetalleTablaPosicionesToMap(entidad);
            return BDServices.InsertCommand(TABLA_DETALLE_TABLA_DE_POSICIONES, diccionario);
        }
        public static void EliminarDetalleTablaPosiciones(int id)
        {
            BDServices.DeleteCommand(TABLA_DETALLE_TABLA_DE_POSICIONES, id);
        }
        public static void ActualizarDetalleTablaPosiciones(DetalleTablaPosicionesEntity entidad)
        {
            DetalleTablaPosicionesToMap(entidad);
            BDServices.UpdateCommand(TABLA_DETALLE_TABLA_DE_POSICIONES, diccionario, entidad.Id);
        }
        public static DetalleTablaPosicionesEntity SeleccionarDetalleTablaPosiciones(int id, bool cerrarConexion)
        {
            DetalleTablaPosicionesToMap(null);
            var dataReader = BDServices.SelectCommand(TABLA_DETALLE_TABLA_DE_POSICIONES, diccionario, id);
            var lista = MapToDetalleTablaPosiciones(dataReader, cerrarConexion);

            return lista[0];
        }
        public static List<DetalleTablaPosicionesEntity> SeleccionarTodasDetalleTablaPosiciones(bool cerrarConexion)
        {
            var dataReader = BDServices.SelectAllCommand(TABLA_DETALLE_TABLA_DE_POSICIONES);
            return MapToDetalleTablaPosiciones(dataReader, cerrarConexion);
        }

        private static Dictionary<string, object> DetalleTablaPosicionesToMap(DetalleTablaPosicionesEntity entidad)
        {
            Dictionary<string, object> diccionarioDetalle = new Dictionary<string, object>();

            if (entidad == null)
            {
                entidad = new DetalleTablaPosicionesEntity();
            }

            diccionarioDetalle.Add("tabla_id", entidad.TablaId);
            diccionarioDetalle.Add("boleta_id", entidad.Boleta.Id);
            diccionarioDetalle.Add("puntos", entidad.Puntaje);

            return diccionarioDetalle;

        }
        private static List<DetalleTablaPosicionesEntity> MapToDetalleTablaPosiciones(SqlDataReader dataReader, bool cerrarConexion)
        {
            var lista = new List<DetalleTablaPosicionesEntity>();

            while (dataReader.Read())
            {
                var entidad = new DetalleTablaPosicionesEntity();

                entidad.Id = (int)dataReader["id"];
                entidad.TablaId = (int)dataReader["tabla_id"];
                entidad.Puntaje = (int)dataReader["puntos"];
                entidad.Boleta = SeleccionarBoleta((int)dataReader["boleta_id"], false);

                lista.Add(entidad);
            }

            dataReader.Close();
            if (cerrarConexion)
                DALSQLServer.Instancia().Conexion.Close();

            return lista;
        }

        #endregion
    }
}
